#include "cvecteur3f.h"

CVecteur3f::CVecteur3f()
{
}

CVecteur3f::CVecteur3f(float x, float y, float z)
{
	this->x = x;
	this->y = y;
	this->z = z;
}

CVecteur3f::CVecteur3f(CPoint3f A, CPoint3f B)
{
	this->x = B.GetX() - A.GetX();
	this->y = B.GetY() - A.GetY();
	this->z = B.GetZ() - A.GetZ();
}

void CVecteur3f::normalize()
{
	float length = CPoint3f(0.0, 0.0, 0.0).Distance(CPoint3f(this->x, this->y, this->z));
	this->x /= length;
	this->y /= length;
	this->z /= length;
}

void CVecteur3f::operator=(const CVecteur3f &p)
{
	this->x = p.x;
	this->y = p.y;
	this->z = p.z;
}

CPoint3f CVecteur3f::operator+ (CPoint3f p)
{
		CPoint3f p2(p.GetX() + this->x, p.GetY() + this->y, p.GetZ() + this->z );
		return p2;
}

CPoint3f CVecteur3f::operator- (CPoint3f p)
{
		CPoint3f p2(p.GetX() - this->x, p.GetY() - this->y, p.GetZ() - this->z);
		return p2;
}

CVecteur3f CVecteur3f::operator* (float c)
{
		CVecteur3f v2(this->x *c, this->y * c, this->z * c );
		return v2;
}

CVecteur3f CVecteur3f::operator- (CVecteur3f v)
{
		CVecteur3f v2(this->x - v.x, this->y - v.y, this->z - v.z );
		return v2;
}

float CVecteur3f::operator* (CVecteur3f v)
{
		return this->x * v.x + this->y * v.y + this->z * v.z;
}

CVecteur3f CVecteur3f::operator +(CVecteur3f v)
{
	return CVecteur3f(this->x + v.x, this->y + v.y, this->z + v.z);
}

CVecteur3f CVecteur3f::crossProduct(CVecteur3f P)
{
	return CVecteur3f((this->y*P.z)-(this->z*P.y),
					  (this->z*P.x)-(this->x*P.z),
					  (this->x*P.y)-(this->y*P.x));
}

float CVecteur3f::length()
{
	return sqrt(this->length2());
}

float CVecteur3f::length2()
{
	return pow(this->x, 2)+pow(this->y,2)+pow(this->z,2);
}

float CVecteur3f::angle(CVecteur3f V)
{
	float n1 = this->length2(), n2 = V.length2(), scal = V*(*this);
	float angle = acos(scal/sqrt(n1*n2));
	if (angle >= M_PI/2.0 && angle >= M_PI)
		angle -= M_PI;
	else
	if (angle <= -M_PI/2.0 && angle >= -M_PI)
		angle += M_PI;
	return angle;
//	return	acos(((V.x * this->x) + (V.y * this->y) + (V.z * this->z)) / sqrt((pow(V.x,2)+pow(V.y,2)+pow(V.z,2)) * (pow(this->x,2)+pow(this->y,2)+pow(this->z,2))));
}

